package display3D.objet3D
{
	import Tools.Geometry;
	
	import alternativa.engine3d.core.Clipping;
	import alternativa.engine3d.core.MouseEvent3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.Object3DContainer;
	import alternativa.engine3d.core.Sorting;
	import alternativa.engine3d.core.Vertex;
	import alternativa.engine3d.materials.FillMaterial;
	import alternativa.engine3d.materials.TextureMaterial;
	import alternativa.engine3d.objects.BSP;
	import alternativa.engine3d.objects.Mesh;
	
	import caurina.transitions.Tweener;
	
	import flash.display.InteractiveObject;
	import flash.display.Loader;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.net.URLRequest;
	
	import mx.controls.Alert;
	import mx.utils.OnDemandEventDispatcher;
	
	
	
	/**
	 * Classe représantant une Peinture dans notre salle3D
	 * @author Arnaud
	 */
	public class Peinture extends EventDispatcher
	{
		
		/**
		 * Evenement lors qu'une oeuvre est a proximité
		 * @default "OEUVRE_PROXIMITE"
		 */
		public static var OEUVRE_PROXIMITE = "OEUVRE_PROXIMITE";
		
		/**
		 * Evenement lors du click sur une peinture
		 * @default "CLICK_PEINTURE"
		 */
		public static var CLICK_PEINTURE = "CLICK_PEINTURE";
		
		/**
		 * Conteneur de notre salle 3D
		 */
		private var _scene:Object3DContainer;
		/**
		 * Hauteur maximum d'une peinture
		 * @default 200
		 */
		public static var hauteurMaxPeinture:int = 200;
		/**
		 * Largeur maximun d'une peinture
		 * @default 200
		 */
		public static var largeurMaxPeinture:int = 200;
		/**
		 * Mur contenant notre peinture
		 */
		private var _mur:Mur;
		private var _charge:Boolean;
		private var _id:String;
		private var _type:String;
		private var _x:*;
		private var _y:*;
		private var _description:String;
		private var _chemin:String;
		private var _objet3D:Vector.<Object3D>;
		private var _soundPath:String;
		
		/**
		 * Constructeur
		 * @param id identifiant de la porte
		 * @param type type de la porte
		 * @param distance 
		 * @param x
		 * @param y
		 */
		public function Peinture(id:String,type:String,description:String,x:*,y:*,chemin:String)
		{
			this._id = id;
			this._type = type;
			this._description = description;
			this._x = x;
			this._y = y;
			this._chemin = chemin;
			this._charge = false;
			_objet3D = new Vector.<Object3D>;
		}
		
				
		/**
		 * Dessine la porte dans la scene
		 * @param scene Scene3D
		 */
		public function draw(scene:Object3DContainer,mur:Mur):void
		{
			this._scene = scene;
			this._mur = mur;
			loadBitmap();
		}
		
		/**
		 * Charge l'image de la peinture
		 */
		private function loadBitmap():void{
			var loader:Loader = new Loader();
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, afficherPeinture);
			loader.load(new URLRequest(this._chemin));
		}
		
		/**
		 * Affiche la peinture une fois l'image chargé
		 * @param evt Event.COMPLETE
		 */
		private function afficherPeinture(evt:Event):void
		{
			var bmp:TextureMaterial = new TextureMaterial(evt.currentTarget.content.bitmapData);
			var longueurMur:* = Geometry.distance(_mur.x1,_mur.y1,_mur.x2,_mur.y2);
			var widthscale:* = bmp.texture.width/(Peinture.largeurMaxPeinture);
			var heightscale:* = bmp.texture.height/(Peinture.hauteurMaxPeinture);
			var rapport:* = bmp.texture.height/widthscale;
			var nwidth:*;
			var nheight:*;
			
			
			//Calcul des dimension de l'oeuvre
			if(rapport < Peinture.hauteurMaxPeinture)
			{nwidth = Peinture.largeurMaxPeinture}
			else
			{nwidth = bmp.texture.width/heightscale;}
			
			if(rapport < Peinture.hauteurMaxPeinture)
			{nheight = rapport;}
			else
			{nheight = Peinture.hauteurMaxPeinture}
			
			//Calcul des coordonnées de l'oeuvre
			var v:Array = Geometry.coordonneVecteur(_mur.x1,_mur.y1,_mur.x2,_mur.y2);
			//Vecteur normalisé mur
			var vN:Array = new Array;
			vN[0] = v[0]/longueurMur;
			vN[1] = v[1]/longueurMur;
			
			//Calcul des coordonnees
			var point1:Array = new Array;
			var point2:Array = new Array;
			
			point1[0] = this.x -(vN[0]*nwidth/2);
			point1[1] = this.y -(vN[1]*nwidth/2);
			
			point2[0] = this.x +(vN[0]*nwidth/2);
			point2[1] = this.y +(vN[1]*nwidth/2);
			
			var distM:* = Geometry.distance(point1[0],point1[1],point2[0],point2[1]);
			
			//Vecteur perpendiculaire au mur
			var vPer:Array = new Array;
			vPer[0] = -(point1[1] - point2[1]);
			vPer[1] = (point1[0] - point2[0]); 
			
			//Vecteur normalisé perpendiculaire
			var vNper:Array = new Array;
			vNper[0] = vPer[0]/distM;
			vNper[1] = vPer[1]/distM;				
			
			var maxZ:* = Mur.hauteur-((Mur.hauteur-nheight)/2);
			var minZ:* = maxZ-nheight;
			
			var meshp:Mesh = new Mesh;
			var v1p:Vertex = meshp.addVertex(point1[0]+vNper[0]*10, point1[1]+vNper[1]*10, maxZ, 0, 0, "v1p");
			var v2p:Vertex = meshp.addVertex(point1[0]+vNper[0]*10, point1[1]+vNper[1]*10, minZ, 0, 1, "v2p");
			var v3p:Vertex = meshp.addVertex(point2[0]+vNper[0]*10, point2[1]+vNper[1]*10, minZ, 1, 1, "v3p");
			var v4p:Vertex = meshp.addVertex(point2[0]+vNper[0]*10, point2[1]+vNper[1]*10,  maxZ, 1, 0, "v4p");
			meshp.addQuadFace(v1p,v2p,v3p,v4p, bmp,"facePorte2");
			meshp.addQuadFace(v4p,v3p,v2p,v1p, bmp,"facePorte2");
			meshp.calculateFacesNormals(true);
			meshp.clipping = Sorting.DYNAMIC_BSP;
			meshp.calculateBounds();
			meshp.addEventListener(MouseEvent3D.CLICK,peintureClick);			
				
			//Affichage de la peinture
			_scene.addChild(meshp);
			_objet3D.push(meshp);
		}
		
		/**
		 * Supprime la peinture de la scene
		 * @param scene Conteneur de notre salle3D
		 */
		public function supprimerPeinture(scene:Object3DContainer):void
		{
			for each (var objet:Object3D in objet3D)
			{
				scene.removeChild(objet);
			}
		}
		
		/**
		 * Envoi un evenement CLICK_PEINTURE lorsque l'on clique sur une peinture
		 * @param evt MouseEvent3D.CLICK
		 */
		public function peintureClick(evt:Event):void
		{
			dispatchEvent(new Event(Peinture.CLICK_PEINTURE));
		}

		/**
		 * Indique si la peinture est chargé
		 */
		public function get charge():Boolean
		{
			return _charge;
		}

		/**
		 * @private
		 */
		public function set charge(value:Boolean):void
		{
			_charge = value;
		}

		/**
		 * Identifiant de la peinture
		 */
		public function get id():String
		{
			return _id;
		}

		/**
		 * @private
		 */
		public function set id(value:String):void
		{
			_id = value;
		}

		/**
		 * Type de la peinture
		 */
		public function get type():String
		{
			return _type;
		}

		/**
		 * @private
		 */
		public function set type(value:String):void
		{
			_type = value;
		}

		/**
		 * Coordonnée x de la peinture
		 */
		public function get x():*
		{
			return _x;
		}

		/**
		 * @private
		 */
		public function set x(value:*):void
		{
			_x = value;
		}

		/**
		 *Coordonnée y de la peinture 
		 */
		public function get y():*
		{
			return _y;
		}

		/**
		 * @private
		 */
		public function set y(value:*):void
		{
			_y = value;
		}

		/**
		 * Description de l'oeuvre
		 */
		public function get description():String
		{
			return _description;
		}

		/**
		 * @private
		 */
		public function set description(value:String):void
		{
			_description = value;
		}

		/**
		 * Chemin de l'image à charger
		 */
		public function get chemin():String
		{
			return _chemin;
		}

		/**
		 * @private
		 */
		public function set chemin(value:String):void
		{
			_chemin = value;
		}

		/**
		 * Contient tout les objets 3D du sol
		 */
		public function get objet3D():Vector.<Object3D>
		{
			return _objet3D;
		}

		/**
		 * @private
		 */
		public function set objet3D(value:Vector.<Object3D>):void
		{
			_objet3D = value;
		}

		/**
		 * Chemin du son d'audio description 
		 */
		public function get soundPath():String
		{
			return _soundPath;
		}

		/**
		 * @private
		 */
		public function set soundPath(value:String):void
		{
			_soundPath = value;
		}
		
		
		
	}
}